INF477 - Redes Neuronales Artificiales
Tarea #1: Perceptrones Multicapa o Redes FF
Tarea realizada por:
- Alvaro Salinas -
alvaro.salinase@gmail.com- rol: 201073001-8 - MartÃn Villanueva -
martin.villanueva@alumnos.usm.cl- rol: 201104012-0
DI UTFSM. Septiembre 2016.
import numpy as np
import matplotlib.pyplot as plt
# sklearn utilities
from sklearn.preprocessing import StandardScaler
from sklearn.cross_validation import KFold
from sklearn.cross_validation import train_test_split
# keras functionalities
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.optimizers import SGD
1.- El XOR¶
Parte (a)¶
La función xor_generator(m) que se muestra a continuación genera $m$ datos aleatorios con la distribución que asemeja el comportamiento de XOR. La estrategia seguida fue generar puntos aleatorios en la región $[-1,1] \times [-1,1]$, etiquetando a los puntos de los cuadrantes I y III con $0$, y a los puntos de los cuadrantes II y IV con $1$.
Adicionalmente, para cada cuadrante se realizó una transformación lineal para alejar a los puntos de los ejes. Lo último es debido a que de otra manera, cuando existen puntos de distinta clase muy cercanos entre sà (en un eje), el problema se vuelve más complejo.
Observación: Esta distribución de puntos se dice simular XOR, pues simula el comportamiento de operador lógico exclusive or. Cuando dos puntos tienen coordenada $(x,y)$ de distintas signo se dice que pertenecen a la clase $1$, y cuando las coordenadas $(x,y)$ tienen mismo signo, pertenecen a la clase $0$.
# for reproducibility of experiments
np.random.seed(1)
def xor_generator(m):
"""
m: number of points to generate
"""
# generate m random points on [-1,1]x[-1,1]
X = 2.*np.random.random(m)-1.
Y = 2.*np.random.random(m)-1.
# arrangement to cluster the points
x_mask = X>0.
y_mask = Y>0.
X[x_mask] *= 0.8; X[x_mask] += 0.1
X[~x_mask] *= 0.8; X[~x_mask] -= 0.1
Y[y_mask] *= 0.8; Y[y_mask] += 0.1
Y[~y_mask] *= 0.8; Y[~y_mask] -= 0.1
XY = np.vstack([X,Y]).T
# generating the labels
y = np.zeros(m, dtype=np.int)
mask = np.multiply.reduce(XY, axis=1) > 0.
y[mask] = 1
return (XY, y)
def xor_plot(X,y):
X0 = X[y==0]
X1 = X[y==1]
plt.figure(figsize=(7,7))
plt.scatter(X0[:,0], X0[:,1], c='b')
plt.scatter(X1[:,0], X1[:,1], c='r')
plt.plot((-1.1,1.1),(0,0),'k--')
plt.plot((0,0),(-1.1,1.1),'k--')
plt.xlim([-1.1,1.1])
plt.ylim([-1.1,1.1])
plt.show()
Se generan a continuación 2000 datos aleatorios, mostrando su distribución gráficamente.
X,y = xor_generator(2000)
xor_plot(X,y)
A continuación se generan los conjuntos de entrenamiento, validación y prueba. De los 2000 datos generados, 1000 son de entrenamiento y 1000 de prueba. Sin embargo de los 1000 de entrenamiento, 20% se ha dejado para la validación durante el entrenamiento de la red.
Nota: Dado que los datos se generaron aleatoriamente, se ha omitido particionar estos conjuntos de forma aleatoria y se ha realizado de forma secuencial.
# training data
X_tr = X[0:800]
y_tr = y[0:800]
# validation data
X_val = X[800:1000]
y_val = y[800:1000]
# testing data
X_ts = X[1000::]
y_ts = y[1000::]
# training data
xor_plot(X_tr, y_tr)
Parte (b)¶
En esta primera parte se ha construido una red consistente de una única neurona con las siguientes caracterÃsticas:
- Inicialización de pesos distribuida normal.
- Función de activación sigmoidal. Dado que la salida está entre 0 y 1,
kerasutiliza este valor para determinar la correspondiente clase. - Algoritmo de entrenamiento:
ADAM. Este es un eficiente y robusto algoritmo estocástico, basado en estimaciones de bajo orden para el momentum. Fue elegido para asegurar la convergencia. - Cross-Entropy binaria como función de pérdida: $L(y, \tilde{y}) = - \tilde{y}\log(y) - (1-\tilde{y})\log(1-y)$ ($\tilde{y}$ predicción de $y$). Esto pues esta función de pérdida es una elección estandar para problemas de clasificación binária.
- Número de épocas: 300.
# building the model
model0 = Sequential()
model0.add(Dense(output_dim=1, input_dim=2, activation='sigmoid', init='normal'))
# compiling the model
model0.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# fitting the model
hist0 = model0.fit(X_tr, y_tr, nb_epoch=300, verbose=0, validation_data=(X_val, y_val))
La performance obtenida sobre el conjunto de prueba se muestra a continuación:
scores = model0.evaluate(X_ts, y_ts, verbose=0)
print("\n{0}: {1}%".format('Accuracy', scores[1]*100))
Este resultado nos indÃca que un simple neurona tiene un accuracy $\approx$50%, es decir, se comporta logra clasificar bien sólo la mitad de los datos (similar a un clasificador aleatorio).
Con lo cual se prueba experimentalmente que un sola neurona no resuelve el problema no lineal de XOR. Este es un resultado conocido, dado que, pese a que tiene una activación no lineal, la función de decisión sigue siendo lineal ($w^T x = 0$), y por lo tanto no es posible que logre clasificar data distribuida no linealmente.
Parte (c)¶
Para esta parte se mantiene casi la misma configuración anterior, más unos pequeños ajustes:
- Se agrega una capa oculta con dos neuronas, ambas con función de activación
tanh. - Ambas capas tienen inicialización de pesos distribuida normal.
# building the model
model1 = Sequential()
model1.add(Dense(output_dim=2, input_dim=2, activation='tanh', init='normal'))
model1.add(Dense(output_dim=1, init='normal', activation='sigmoid'))
# compiling the model
model1.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# fitting the model
hist1 = model1.fit(X_tr, y_tr, nb_epoch=300, verbose=0, validation_data=(X_val, y_val))
scores = model1.evaluate(X_ts, y_ts, verbose=0)
print("\n{0}: {1}%".format('Accuracy', scores[1]*100))
Como puede notarse el accuracy sobre el conjunto de prueba aumento de manera notoria. Esto nos demuestra experimentalmente que con tan solo agregar dos neuronas en una capa oculta, la red ahora es capaz de aprender fronteras de decisión no lineales.
A continuación se entrena el mismo modelo anterior, pero con 10 neuronas en la capa oculta.
# building the model
model2 = Sequential()
model2.add(Dense(output_dim=10, input_dim=2, activation='tanh', init='normal'))
model2.add(Dense(output_dim=1, init='normal', activation='sigmoid'))
# compiling the model
model2.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# fitting the model
hist2 = model2.fit(X_tr, y_tr, nb_epoch=300, verbose=0, validation_data=(X_val, y_val))
scores = model2.evaluate(X_ts, y_ts, verbose=0)
print("\n{0}: {1}%".format('Accuracy', scores[1]*100))
El resultado es un ajuste perfecto sobre el test de prueba. Esto va acorde al teorema de aproximación universal; Con una red de 3 capas, y con el número suficiente de neuronas en la capa oculta, es posible aproximar cualquier distribución/función.
"""
Input:
> hist - history object from model.fit() method
Output:
> plot of training and validation loss vs epochs
"""
def history_plot(hist, title=None):
fig = plt.figure(figsize=(16,8))
ax = fig.gca()
ax.set_xticks(np.linspace(1,301,20))
ax.set_yticks(np.linspace(0,1,10))
plt.xlim(0,301)
plt.ylim(0,1)
if title is None:
plt.title('Mean Squared Training and Validation Error')
else: plt.title(title)
plt.plot(range(1,301), hist.history['loss'], 'bo-', label='MSE train')
plt.plot(range(1,301), hist.history['val_loss'], 'go-', label='MSE validation')
plt.legend(loc=1)
plt.xlabel('Number of Epochs')
plt.ylabel('MSE')
plt.grid()
plt.show()
Parte (a)¶
La lÃnea 4 del siguiente código se encarga de descargar el dataset correspondiente, leerlo (con valores separados por coma) e introducirlo dentro de un data frame de pandas con las etiquetas correspondientes para cada caracterÃstica.
La lÃnea 6 se encarga de generar los conjuntos de entrenamiento y validación. Sobre el data frame anterior, se realiza una separación de 75% para entrenamiento, y 25% para prueba. Como resultado se obtienen los data frame de entrenamiento y prueba respectivos.
import pandas as pd
url = 'http://mldata.org/repository/data/download/csv/regression-datasets-housing/'
df = pd.read_csv(url, sep=',',header=None, names=['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX',
'RM', 'AGE','DIS','RAD','TAX','PTRATIO','B','LSTAT','MEDV'])
from sklearn.cross_validation import train_test_split
df_train,df_test= train_test_split(df,test_size=0.25, random_state=0)
import pandas as pd
url = 'http://mldata.org/repository/data/download/csv/regression-datasets-housing/'
df = pd.read_csv(url, sep=',', header=None, names=['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX',
'RM', 'AGE', 'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV'])
from sklearn.cross_validation import train_test_split
df_train, df_test = train_test_split(df, test_size=0.25, random_state=0)
Parte (b)¶
Como se puede ver de las celdas que siguen, el dataset se caracteriza por lo siguiente:
- 506 ejemplos en total
- 13 caracterÃsticas (hay 14 variables, pero una corresponde a la de salida).
- Las caracterÃsticas estan compuestas en su mayor parte por variables continuas reales y positivas. Sin embargo también hay variables discretas como
ZN,CHAS(categórica),RAD,TAXyPTRATIO.
# mostrando algunas caracterÃsticas del dataset contenido en el frame
print('Numero de ejemplos: {0}'.format(df.shape[0]))
print('Numero de caracterÃsticas: {0}'.format(df.shape[1]))
print(df.info)
df.describe
Parte (c)¶
Si bien en problemas de regresión, los modelos obtenidos al escalar los datos son todos equivalentes, con modificaciones en el tamaño de los pesos asociado a cada caracterÃstica, en el caso particular de las ANN ciertas consideraciones numéricas/prácticas para los cuales la estandarización/normalización ayudan en gran medida.
- Al normalizar las caracterÃsticas, el espacio de búsqueda de los pesos $\mathbf{W}$ se vuelve más uniforme, y los algoritmos de optimización (SGD por ejemplo) lograr recorrerlo de mejor manera, sin estancarse en óptimos locales.
- De acuerdo a la regla de actualización para los pesos $W$, si todas las unidades de entrada tienen valores positivos (que es precisamente nuestro caso!), en cada iteración las actualizaciones que a los pesos serán del mismo signo. Como resultado se obtiene un proceso de aprendizaje lento, y que en la mayorÃa de los casos no logra conveger.
Nota: Para tener resultados consistentes, se ha ocupa la misma transformación sobre datos de entrenamiento y prueba.
# scaling for training set
scaler = StandardScaler().fit(df_train)
df_train_scaled = pd.DataFrame(scaler.transform(df_train), columns=df_train.columns)
y_train_scaled = df_train_scaled.pop('MEDV')
X_train_scaled = df_train_scaled
# the same but for testing set
df_test_scaled = pd.DataFrame(scaler.transform(df_test), columns=df_test.columns)
y_test_scaled = df_test_scaled.pop('MEDV')
X_test_scaled = df_test_scaled
Parte (d)¶
# building the model
model = Sequential()
model.add(Dense(output_dim=200, input_dim=X_train_scaled.shape[1], init='uniform'))
model.add(Activation('sigmoid'))
model.add(Dense(1, init='uniform'))
model.add(Activation('linear'))
# compiling the model
model.compile(optimizer=SGD(lr=0.01), loss='mean_squared_error')
# fitting the model
hist = model.fit(X_train_scaled.as_matrix(), y_train_scaled.as_matrix(), nb_epoch=300,
verbose=1, validation_data=(X_test_scaled.as_matrix(), y_test_scaled.as_matrix()))
En primer lugar es importante mencionar que con learning rate lr=0.2 (tal el trabajo solicitaba) los pesos de la red divergen en la primera época. Por lo tanto experimentalmente se cambió al valor lr=0.01 para el cuál si logra converger.
Los resultados se muestran a continuación:
history_plot(hist)
Como es de esperar, a medida que el número de épocas aumentan tanto el error de entrenamiento como el de validación disminuyen, siendo siempre el error de entrenamiente inferior al de validación, puesto que la red tiende a sobreajustar los datos con los que se le entrena.
Es importante notar que pasadas las 100 épocas no hay grandes mejoras en ambos errores.
Parte (e)¶
Se repite el procedimiento anterior (con mismo lr=0.01), pero ahora con función de activación relu para la capa oculta.
# building the model
model = Sequential()
model.add(Dense(output_dim=200, input_dim=X_train_scaled.shape[1], init='uniform'))
model.add(Activation('relu'))
model.add(Dense(1, init='uniform'))
model.add(Activation('linear'))
# compiling the model
model.compile(optimizer=SGD(lr=0.01), loss='mean_squared_error')
# fitting the model
hist = model.fit(X_train_scaled.as_matrix(), y_train_scaled.as_matrix(), nb_epoch=300,
verbose=1, validation_data=(X_test_scaled.as_matrix(), y_test_scaled.as_matrix()))
history_plot(hist)
El resultado anterior muestra una gran mejora respecto de lo obtenido con funciones de activación sigmoidales. La siguiente tabla resume los resultados finales para ambos casos.
sigmoid |
relu |
|
|---|---|---|
| Training | 0.2377 | 0.0683 |
| Validation | 0.3584 | 0.2022 |
Adicionalmente como se aprecia de los gráficos, la convergencia es mucho más uniforme en la caso de relu, esto es, se nota una tendencia decreciente clara y casi monotonamente decreciente.
Parte (f)¶
n_lr = 20
learning_rate = np.linspace(0, 0.03, n_lr+1)[1::]
hist_list = list()
for i in range(n_lr):
# building the model
model = Sequential()
model.add(Dense(output_dim=200, input_dim=X_train_scaled.shape[1], init='uniform'))
model.add(Activation('sigmoid'))
model.add(Dense(1, init='uniform'))
model.add(Activation('linear'))
model.compile(optimizer=SGD(lr=learning_rate[i]), loss='mean_squared_error')
# training the network
hist = model.fit(X_train_scaled.as_matrix(), y_train_scaled.as_matrix(), nb_epoch=300,
verbose=0, validation_data=(X_test_scaled.as_matrix(), y_test_scaled.as_matrix()))
# storing the results
hist_list.append(hist)
# making training and validation error plots
for i,hist in enumerate(hist_list):
title = 'Mean Squared Training and Validation Error. Learning rate: {0}'.format(learning_rate[i])
history_plot(hist, title)
Parte (g)¶
5-Fold Cross Validation¶
Xm = X_train_scaled.as_matrix()
ym = y_train_scaled.as_matrix()
kfold = KFold(len(Xm), 5)
cvscores = []
for i, (train, val) in enumerate(kfold):
# create model
model = Sequential()
model.add(Dense(200, input_dim=Xm.shape[1], init='uniform'))
model.add(Activation('sigmoid'))
model.add(Dense(1, init='uniform'))
model.add(Activation('linear'))
# Compile model
sgd = SGD(lr=0.01)
model.compile(optimizer=sgd, loss='mean_squared_error')
# Fit the model
model.fit(Xm[train], ym[train], nb_epoch=300, verbose=0)
# evaluate the model
scores = model.evaluate(Xm[val], ym[val])
cvscores.append(scores)
mse_cv = np.mean(cvscores)
mse_cv
10-Fold Cross Validation¶
kfold = KFold(len(Xm), 10)
cvscores = []
for i, (train, val) in enumerate(kfold):
# create model
model = Sequential()
model.add(Dense(200, input_dim=Xm.shape[1], init='uniform'))
model.add(Activation('sigmoid'))
model.add(Dense(1, init='uniform'))
model.add(Activation('linear'))
# Compile model
sgd = SGD(lr=0.01)
model.compile(optimizer=sgd, loss='mean_squared_error')
# Fit the model
model.fit(Xm[train], ym[train], nb_epoch=300, verbose=0)
# evaluate the model
scores = model.evaluate(Xm[val], ym[val])
cvscores.append(scores)
mse_cv = np.mean(cvscores)
mse_cv
Parte (h)¶
n_decay = 10
learning_decay = np.logspace(-6, 0, n_decay)
hist_list = list()
for i in range(n_decay):
# building the model
model = Sequential()
model.add(Dense(output_dim=200, input_dim=X_train_scaled.shape[1], init='uniform'))
model.add(Activation('sigmoid'))
model.add(Dense(1, init='uniform'))
model.add(Activation('linear'))
model.compile(optimizer=SGD(lr=0.01, decay=learning_decay[i]), loss='mean_squared_error')
# training the network
hist = model.fit(X_train_scaled.as_matrix(), y_train_scaled.as_matrix(), nb_epoch=300,
verbose=0, validation_data=(X_test_scaled.as_matrix(), y_test_scaled.as_matrix()))
# storing the results
hist_list.append(hist)
# making training and validation error plots
for i,hist in enumerate(hist_list):
title = 'Mean Squared Training and Validation Error. Decay factor: {0}'.format(learning_decay[i])
history_plot(hist, title)
Parte (i)¶
n_momentum = 20
momentum = np.linspace(0., 1., n_momentum+1)[1::]
hist_list = list()
for i in range(n_momentum):
# building the model
model = Sequential()
model.add(Dense(output_dim=200, input_dim=X_train_scaled.shape[1], init='uniform'))
model.add(Activation('sigmoid'))
model.add(Dense(1, init='uniform'))
model.add(Activation('linear'))
model.compile(optimizer=SGD(lr=0.01, decay=momentum[i]), loss='mean_squared_error')
# training the network
hist = model.fit(X_train_scaled.as_matrix(), y_train_scaled.as_matrix(), nb_epoch=300,
verbose=0, validation_data=(X_test_scaled.as_matrix(), y_test_scaled.as_matrix()))
# storing the results
hist_list.append(hist)
# making training and validation error plots
for i,hist in enumerate(hist_list):
title = 'Mean Squared Training and Validation Error. Momentum: {0}'.format(momentum[i])
history_plot(hist, title)
Parte (j)¶
n_batches = 20
batch_sizes = np.round(np.linspace(1,X_train_scaled.shape[0],n_batches))
print(batch_sizes)
hist_list = list()
for i in range(n_batches):
# building the model
model = Sequential()
model.add(Dense(output_dim=200, input_dim=X_train_scaled.shape[1], init='uniform'))
model.add(Activation('sigmoid'))
model.add(Dense(1, init='uniform'))
model.add(Activation('linear'))
model.compile(optimizer=SGD(lr=0.01), loss='mean_squared_error')
# training the network
hist = model.fit(X_train_scaled.as_matrix(), y_train_scaled.as_matrix(), nb_epoch=300, batch_size=batch_sizes[i],
verbose=0, validation_data=(X_test_scaled.as_matrix(), y_test_scaled.as_matrix()))
# storing the results
hist_list.append(hist)
# making training and validation error plots
for i,hist in enumerate(hist_list):
title = 'Mean Squared Training and Validation Error. Batch Size: {0}'.format(batch_sizes[i])
history_plot(hist, title)
3.- Reconocimiento de imágenes en CIFAR10¶